Method and apparatus for word-level netlist reduction and verification using same

ABSTRACT

A computer implemented representation of a circuit design is reduced by representing the circuit design as a data structure defining a netlist. A first set of nodes is identified in the netlist that includes datapath nodes, preferably nodes that do not intermingle data and control. The first set of nodes is segmented into segment widths that correspond to uniformly treated segments of the corresponding words. A second set of nodes, including nodes that intermingle data and control, are converted into bit-level nodes. The segmented nodes are analyzed to define reduced safe sizes by applying a computer implemented function. An updated data structure representing the circuit design is then generated using the reduced safe sizes of the segmented nodes.

BACKGROUND

1. Field of the Invention

The present invention relates to integrated circuit design, and more particularly to electronic design automation tools and tools for verification and analysis of complex designs including memory.

2. Description of Related Art

Analysis of word-level designs, which leverages design information captured at a higher level than that of individual wires and primitive gates, is a new frontier in hardware verification. At the word level, data path elements and data packets are viewed as entities in their own right as opposed to a group of bit-level signals without any special semantics.

Today's model checking technology works well for checking control oriented properties. Typical model checking consists of an exhaustive state space exploration for verifying that some specified properties hold in the circuit design, and is a very intensive user of computing resources. However, it does not work well with designs where there are wide datapaths, and large memories. Previous approaches tried to speed up the process by reading designer annotations, or computing increasingly precise abstractions of the design. However, annotations are very time consuming for the designer, and the computation of abstractions can be as hard as solving the original problem.

There has been a lot of activity lately around word-level formula decision procedures such as SMT solvers (S. Ranise and C. Tinelli. Satisfiability modulo theories. Trends and Controversies—IEEE Intelligent Systems Magazine, December 2006) and reduction-based procedures like UCLID (R. Bryant, S. Lahiri, and S. Seshia. Modeling and verifying systems using a logic of counter arithmetic with lambda expressions and uninterpreted functions. In Proc. of the Computer Aided Verification Conf., 2002) and BAT (P. Manolios, S. Srinivasan, and D. Vroon. BAT: The bit-level analysis tool. In Proc. of the Computer Aided Verification Conf., 2007). However, as promising as this direction of research is, the use of these procedures for model checking is inherently restricted in that they analyze formulas rather than sequential systems. This has two consequences: First of all, sequential properties can only be checked by these procedures by relying on methods such as induction and interpolation that employ bounded checks to infer unbounded correctness. Second, these procedures do not fit into a transformation-based approach to sequential system verification (J. Baumgartner, T. Gloekler, D. Shanmugam, R. Seigler, G. V. Huben, H. Mony, P. Roessler, and B. Ramanandray. Enabling large-scale pervasive logic verification through multi-algorithmic formal reasoning. In Proc. of the Formal Methods in CAD Conf., 2006), where sequential verification problems are iteratively simplified and processed by any of a large set of back-end model checkers.

Therefore, it would be desirable to efficiently implement for practical word-level model checking of both bounded and unbounded properties for hardware designs. It is further desirable to accomplish this goal with technology that (1) requires little or no additional input from the user, (2) performs well compared to a straight bit-level sequential analysis of a given netlist, and (3) provides the possibility of speedups when there are significant parts of the design that can be treated on the word-level.

SUMMARY

A netlist reduction method is provided where a word-level netlist representing a sequential circuit design is abstracted to an equivalent but smaller netlist, which can be analyzed by standard verification tools and by other tools that operate on netlists.

A computer implemented representation of a sequential circuit design can be reduced in a method that includes representing the circuit design as a data structure defining a netlist including a plurality of nodes, such as in the form of a directed acyclic graph DAG. For example, a circuit design represented by a high-level description language can be processed to produce this type of data structure. A first set of word-level nodes is identified in the netlist that includes nodes having some data path segments that are treated uniformly. The first set of word-level nodes is segmented into segment widths that correspond to uniformly treated segments of the corresponding words. A second set of nodes that does not include uniformly treated segments as used for identifying the first set of nodes, are converted into bit-level nodes. The segmented nodes are analyzed to define reduced safe sizes by applying a computer implemented function. An updated data structure representing the circuit design is then generated using the reduced safe sizes of the segmented nodes. The updated data structure can then be analyzed to determine whether the circuit design satisfies a pre-specified property, such as a safety property, and in a preferred mode can fit into a transformation-based approach to sequential system verification in a data processing system used for integrated circuit design and manufacturing.

In implementations using the directed acyclic graph data structure mentioned above, top-level nodes in the graph include said word-level nodes representing circuit outputs and next-state variables; bottom-level nodes in the graph include said word-level nodes representing inputs, current state variables and binary constant vectors; and internal nodes in the graph include said word-level nodes representing operators.

The first set of nodes for a particular circuit design includes word-level nodes representing comparison operators for (equal to) and (not equal to), word-level nodes representing multiplexer operators, word-level nodes representing concatenation operators, word-level nodes representing extraction operators, word-level nodes representing inputs, word-level nodes representing state variables and word-level nodes representing binary constants. The second set of nodes for a particular design includes word-level nodes representing arithmetic operators, word-level nodes representing comparison operators for (less than), (less than or equal to), (greater than), and (greater than or equal to), word-level nodes representing logical AND operators, and word-level nodes representing logical NOT operators.

The segmenting and converting processes are facilitated by registering each node in the data structure and constructing a partition list for the node, identifying the segmentation of the node, and a dependency group including each segment of the node. The partition list and the dependency group constructed when the node is registered identifies a single segment of the node including bits (0 . . . k−1) where the node has a width k. The dependency groups are maintained in the process so that they identify nodes that depend upon a particular node being registered, and nodes upon which it depends. The segmenting operation splits nodes within a particular dependency group that includes a particular node, until the segmentations of the nodes in the dependency group match. The converting operation splits nodes in the dependency group into single bit segments.

Preferably, the partition lists for nodes are maintained in a data structure organized for probabilistic search, such as a skip list data structure.

Reduced safe sizes are found in embodiments using dependency groups by processing the segments of nodes in the dependency groups to find reduced safe sizes for the segments, and then summing the segments for each node. A useful formula for finding reduced safe sizes is that the reduced safe size is min(S, log₂(N_(S)+2)), where the dependency group includes a segments of width S, and a number N_(S) of state variable and input segments of size S and at most 2 constants.

In addition to the segmenting and converting processes, where the plurality of nodes includes current state and the next state variables, the current state and next state variables are processed to ensure consistent segmentation.

The methods described herein combine fast static analysis that finds parts of signals that are treated as uniform “packets” with static reduction that resizes these packets to smaller sizes that preserve the provability status of properties subject of the verification procedures. Preferred embodiments can be implemented that (1) do not require user annotations, (2) as a result of the fact that the worst case reduction is the original system, are guaranteed to not slow down the solving, and (3) are extremely fast.

The technology described herein can be implemented as a process executed on a data processing machine, as a data processing machine adapted to execute the procedures described, and as a computer program executable by a data processing machine, and stored on a computer readable data storage medium. In addition, the technology herein is part of a process for manufacturing an integrated circuit including the development of data defining a pattern, such as layout data for a mask or a set of masks used in lithographic processes in integrated circuit manufacturing.

Other aspects and advantages of the present invention can be seen in the drawings, detailed description and claims which follow.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 shows a simplified representation of an illustrative integrated circuit design flow.

FIG. 2 is a simplified block diagram of a computer system suitable for use with embodiments of the technology, as well as a circuit design and circuit embodiments of the technology.

FIG. 3 is a simplified flow chart for a process for reducing the size of a data structure representing a circuit design, and performing a verification process using the reduced data structure.

FIG. 4 is a representative example of a netlist implemented as a directed acyclic graph including a plurality of nodes.

FIG. 5 is a simplified drawing showing data structures used in the process of FIGS. 9-13.

FIG. 6 illustrates an operation to split a partitioned node.

FIG. 7 illustrates an operation to merge dependency groups for a set of nodes.

FIG. 8 illustrates an operation to make a set of nodes compatible.

FIGS. 9-13 show a more detailed flow chart of a process for reducing the size of a data structure representing a circuit design.

FIG. 14 illustrates an operation to process extraction nodes.

DETAILED DESCRIPTION

FIG. 1 is a simplified representation of an illustrative integrated circuit design flow. As with all flowcharts herein, it will be appreciated that many of the steps of FIG. 1 can be combined, performed in parallel or performed in a different sequence without affecting the functions achieved. In some cases a rearrangement of steps will achieve the same results only if certain other changes are made as well, and in other cases a rearrangement of steps will achieve the same results only if certain conditions are satisfied. Such rearrangement possibilities will be apparent to the reader.

At a high level, the process of FIG. 1 starts with the product idea (block 100) and is realized in an EDA (Electronic Design Automation) software design process (block 110). When the design is finalized, the fabrication process (block 150) and packaging and assembly processes (block 160) occur, ultimately resulting in finished integrated circuit chips (result 170).

The EDA software design process (block 110) is actually composed of a number of steps 112-130, shown in linear fashion for simplicity. In an actual integrated circuit design process, the particular design might have to go back through steps until certain tests are passed. Similarly, in any actual design process, these steps may occur in different orders and combinations. This description is therefore provided by way of context and general explanation rather than as a specific, or recommended, design flow for a particular integrated circuit.

A brief description of the components steps of the EDA software design process (block 110) will now be provided.

System design (block 112): The designers describe the functionality that they want to implement, they can perform what-if planning to refine functionality, check costs, etc. Hardware-software architecture can occur at this stage. Example EDA software products from Synopsys, Inc. that can be used at this step include Model Architect, Saber, System Studio, and DesignWare® products.

Logic design and functional verification (block 114): At this stage, Hardware Description Language (HDL) code, such as the VHDL or Verilog code, for modules in the system is written and the design is checked for functional accuracy. More specifically, the design is checked to ensure that it produces the correct outputs in response to particular input stimuli. Example EDA software products from Synopsys, Inc. that can be used at this step include VCS, VERA, DesignWare®, Magellan, Formality, ESP and LEDA products. The word-level netlist reduction technology described in more detail below can be implemented as a part of, or as an add-on tool, for the Magellan product for example.

Synthesis and design for test (block 116): Here, the VHDL/Verilog is translated to a netlist. The netlist can be optimized for the target technology. Additionally, the design and implementation of tests to permit checking of the finished chip occurs. Example EDA software products from Synopsys, Inc. that can be used at this step include Design Compiler®, Physical Compiler, Test Compiler, Power Compiler, FPGA Compiler, TetraMAX, and DesignWare® products.

Netlist verification (block 118): At this step, the netlist is checked for compliance with timing constraints and for correspondence with the VHDL/Verilog source code. Example EDA software products from Synopsys, Inc. that can be used at this step include Formality, PrimeTime, and VCS products.

Design planning (block 120): Here, an overall floor plan for the chip is constructed and analyzed for timing and top-level routing. Example EDA software products from Synopsys, Inc. that can be used at this step include Astro and IC Compiler products.

Physical implementation (block 122): The placement (positioning of circuit elements) and routing (connection of the same) occurs at this step. Example EDA software products from Synopsys, Inc. that can be used at this step include AstroRail, Primetime, and Star RC/XT products.

Analysis and extraction (block 124): At this step, the circuit function is verified at a transistor level, this in turn permits what-if refinement. Example EDA software products from Synopsys, Inc. that can be used at this stage include AstroRail, PrimeRail, Primetime, and Star RC/XT products.

Physical verification (block 126): At this stage various checking functions are performed to ensure correctness for: manufacturing, electrical issues, lithographic issues, and circuitry. Example EDA software products from Synopsys, Inc. that can be used at this stage include the Hercules product.

Tape-out (block 127): This stage provides the “tape-out” data for production of masks for lithographic use to produce finished chips. Example EDA software products from Synopsys, Inc. that can be used at this stage include the CATS(R) family of products.

Resolution enhancement (block 128): This stage involves geometric manipulations of the layout to improve manufacturability of the design. Example EDA software products from Synopsys, Inc. that can be used at this stage include Proteus/Progen, ProteusAF, and PSMGen products.

Mask preparation (block 130): This stage includes both mask data preparation and the writing of the masks themselves. Example EDA software products from Synopsys, Inc. that can be used at this stage include CATS(R) family of products.

Embodiments of the netlist reduction technology described herein can be used during one or more of the above-described stages. For example, embodiments of the present invention can be used during logic design and functional verification (block 114 of FIG. 1). At this stage, the VHDL or Verilog code for modules in the system is written and the design is checked for functional accuracy. More specifically, the design is checked to ensure that it produces the correct outputs in response to particular input stimuli.

FIG. 2 is a simplified block diagram of a computer system 210 suitable for use with embodiments of the technology. Computer system 210 typically includes at least one processor 214 which communicates with a number of peripheral devices via bus subsystem 212. These peripheral devices may include a storage subsystem 224, comprising a memory subsystem 226 and a file storage subsystem 228, user interface input devices 222, user interface output devices 220, and a network interface subsystem 216. The input and output devices allow user interaction with computer system 210. Network interface subsystem 216 provides an interface to outside networks, including an interface to communication network 218, and is coupled via communication network 218 to corresponding interface devices in other computer systems. Communication network 218 may comprise many interconnected computer systems and communication links. These communication links may be wireline links, optical links, wireless links, or any other mechanisms for communication of information. While in one embodiment, communication network 218 is the Internet, in other embodiments, communication network 218 may be any suitable computer network.

User interface input devices 222 may include a keyboard, pointing devices such as a mouse, trackball, touchpad, or graphics tablet, a scanner, a touchscreen incorporated into the display, audio input devices such as voice recognition systems, microphones, and other types of input devices. In general, use of the term “input device” is intended to include all possible types of devices and ways to input information into computer system 210 or onto computer network 218.

User interface output devices 220 may include a display subsystem, a printer, a fax machine, or non-visual displays such as audio output devices. The display subsystem may include a cathode ray tube (CRT), a flat-panel device such as a liquid crystal display (LCD), a projection device, or some other mechanism for creating a visible image. The display subsystem may also provide non-visual display such as via audio output devices. In general, use of the term “output device” is intended to include all possible types of devices and ways to output information from computer system 210 to the user or to another machine or computer system.

Storage subsystem 224 stores the basic programming and data constructs that provide the functionality of some or all of the EDA tools described herein, including the netlist reduction technology and verification tools applied for analysis of the reduced netlist. These software modules are generally executed by processor 214.

Memory subsystem 226 typically includes a number of memories including a main random access memory (RAM) 230 for storage of instructions and data during program execution and a read only memory (ROM) 232 in which fixed instructions are stored. File storage subsystem 228 provides persistent storage for program and data files, and may include a hard disk drive, a floppy disk drive along with associated removable media, a CD-ROM drive, an optical drive, or removable media cartridges. The databases and modules implementing the functionality of certain embodiments may be stored by file storage subsystem 228.

Bus subsystem 212 provides a mechanism for letting the various components and subsystems of computer system 210 communicate with each other as intended. Although bus subsystem 212 is shown schematically as a single bus, alternative embodiments of the bus subsystem may use multiple busses.

Computer readable medium 240 can be a medium associated with file storage subsystem 228, and/or with network interface subsystem 216. The computer readable medium can be a hard disk, a floppy disk, a CD-ROM, an optical medium, removable media cartridge, or electromagnetic wave. The computer readable medium 240 is shown storing a circuit design 280, including for example an HDL description of a circuit design, and a reduced netlist created with the described technology. Also shown is a circuit 290 created with the described technology.

Computer system 210 itself can be of varying types including a personal computer, a portable computer, a workstation, a computer terminal, a network computer, a television, a mainframe, or any other data processing system or user device. Due to the ever-changing nature of computers and networks, the description of computer system 210 depicted in FIG. 2 is intended only as a specific example for purposes of illustrating the preferred embodiments. Many other configurations of computer system 210 are possible having more or less components than the computer system depicted in FIG. 2.

FIG. 3 is a basic flowchart for a process for performing a verification step for a circuit design that includes operating on a reduced netlist. In the process of FIG. 3, a word-level netlist including a plurality of nodes is compiled from a high-level description language description of a circuit design, preferably in the form of a directed acyclic graph of nodes (block 300). A standard front end flow takes a Register Transfer Level (RTL) description expressed for example in Hardware Description Language (HDL), supplemented with the definitions of user constraints, properties and other information, and produces the implicitly clocked DAG representation described in detail below. A standard front end flow is used which compiles a circuit design into netlists by processing a hardware design with properties and constraints into a plurality of nodes representing combinational logic over a set of unconstrained inputs I, state variables S and constants. The top of the resulting plurality of nodes contain next-state variables S′ and single bit outputs O. The properties which can be verified using this technology include all properties whose failure is signaled by some output assuming the value “false”, including safety properties. A safety property is a subclass of properties of circuit design, which has the form that some output always holds (i.e., whose failure can always be shown by a finite trace). In addition, each state variable can be assumed to have a fully or partially unknown initial state in some embodiments.

The internal nodes in a graph compiled in this manner include the following:

node1 = not(node2) node1 = and(node2, node3) node1 = arithOp(node2, node3), for arithOp being a member of {+, −, ...} node1 = compOp(node2, node3),    for compOp being a member of {less than,    less than or equal to, equal to, not equal to, greater than    orequal to, greater than} node1 = mux(selector, node2, node3) node1 = extract(x, node2) node1 = concat(node2, node3, ...)

The “not” and “and” operators are bitwise operators in the sense that bit i of the result is generated by applying the Boolean operator to bit i of the input nodes. The “mux” node returns node2 if selector is true and node 3 otherwise. The “extract” node constructs a smaller bit vector by projecting out k bits from position (x) to (x+k−1) of its operand. Finally, the “concat” node forms a larger signal by concatenating its operands to form a larger bit vector. Earlier operands in the argument list to concat become higher order bits, so concat(01, 00) becomes 0100.

The select signal of mux and the output of comparison operator nodes are restricted to have a bit width of one. Such signals are said to be bit-level signals. Signals that are not bit-level signals, are referred to as word-level signals. The term “segment” denotes a group of contiguous bits, and can refer to an entire word, or parts of a word.

Returning to the flow chart in FIG. 3, the plurality of nodes is analyzed to separate datapath nodes from control logic, and to segment the datapath nodes into segment sizes that are treated uniformly (block 301). The segmented datapath portions of the circuit are analyzed to find reduced safe sizes for all word-level and segmented nodes (block 302). A smaller final netlist is generated using the reduced safe sizes which can be analyzed by standard gate-level reductions in model checking algorithms (block 303). The final netlist is analyzed to determine for example, whether the circuit design satisfies a safety property specified by circuit verification tools (Block 304).

FIG. 4 illustrates a netlist implemented as a directed acyclic graph, where top-level nodes include word-level (and/or bit-level) nodes representing circuit outputs (o0) and next-state variables (s0′), where bottom-level nodes include word-level (and/or bit-level) nodes representing inputs (i0, i1, i2), initial state variables (s0) and binary constant vectors (111111111, 111, 000), and where internal nodes include word-level (and/or bit-level) nodes representing operators (n1-n9). In FIG. 4, the superscripts shown adjacent to the node indicators represent widths of the nodes, where the width corresponds with the number of bits. The initial state for s0 ⁹ is set during initialization to using an initialization vector 000000000⁹, and the property of interest is that output o0 ¹ is always true. The circuit generates the next state s0′ for state variable s0 by concatenating three parts. The lowest part is a fresh input value i0, but only if it is not equal to 111 (otherwise it switches in 000). The other two segments are the result of either keeping the current 2 lower order segments (0 . . . 2) and (3 . . . 5) of s0, or swapping in the low order segment (0 . . . 2) of s0 with the upper order segment (6 . . . 9) of s0, depending on the value of two externally controlled inputs i1 and i2. Hence, the system is safe in that the output can never become false. Each node in the graph has an associated signal width k. At places in the present description, the nodes are annotated with a superscript to denote the signal width.

One can see that the circuit design represented in the structure shown in FIG. 4, or in a similar data structure, can be “bitblasted” into an equivalent bit-level netlist by splitting all the variables into single bit segments, and implementing the internal nodes in terms of Boolean, single bit logic. This would result in a netlist where all the signals have a width of one, and the internal nodes are Boolean operators. In order to provide a reduced, word-level netlist as described herein, selective bit blasting is performed by traversing the graph in a depth first manner, identifying segments of datapath nodes that treated uniformly and segmenting these nodes accordingly. All other operators are translated into bit-level constructs. Then, a reduced safe size for the segmented nodes is identified and an updated netlist is generated using the reduced safe sizes for the segmented nodes, and the bit-level constructs.

A technique for performing this analysis involves annotating each node in the graph with information on which of its segments are treated as word-level packages; that is, units of data that are treated uniformly. Analysis of this type to reduce formulas, rather than sequential systems as described here, is described in P. Johannesen, “Speeding up hardware verification by automated datapath scaling,” Ph.D. thesis, Christian-Albrechts-Universit at zu Kiel, 2002, which is incorporated by reference as if fully set forth herein.

FIG. 5 illustrates a simplified data organization for use in a data processing machine performing the process, including the input data structure 500 in which a circuit design is represented by a plurality of nodes arranged as a directed acyclic graph, a partition list 501 containing segmentation information identifying the partitions in the nodes, a list 502 of dependency groups for the segments in the partition list 501, and a reduced data structure 503 provided as output of the process. The partition list 501 maintains a partition at each node into bit segments. For each bit segment of every node, a dependency class is maintained in list 502 that includes segments of nodes that depend on the segment, or that the segment depends upon, and reduced data structure 503 is processed as a result of the procedures described herein.

The data structures are processed using operations on dependency groups and intervals, including registerNode(n), split(n,j), mkCompatible(n1, n2, . . . ), bitblast(n) and MergeDepGps(n1, n1, . . . ).

The creation operator, registerNode(n) adds a node n, having a segment (0 . . . k−1) in the partition list, and constructs a singleton dependency group containing the segment (0 . . . k−1), assuming the node has k bits.

The refining operators split(n,j), mkCompatible(n1, n2, . . . ), and bitblast(n) perform the following functions:

1. split(n, j): This operator finds the segment dependency group for node n that contains the bit j. If the bit j falls internally to the segment interval i . . . k, so that i<j<k, then the dependency group is split into two new groups, the first containing the j−i first bits of each segment, and the other containing the remaining bits of each segment. FIG. 6 illustrates the results of a split operation for the group 600 on the location 1. Thus, the dependency group 600 includes three segments having a width of three bits: Sig0(0 . . . 2), Sig1(0 . . . 2), Sig2(12 . . . 14). After the split (Sig0,1), dependency groups 601 and 602 result, where dependency group 601 includes three segments having a width of two bits: Sig0(0 . . . 1), Sig1(0 . . . 1), Sig2(12 . . . 13); and the dependency group 602 includes three segments having a width of one bit: Sig0(2 . . . 2), Sig1(2 . . . 2), Sig2(14 . . . 14). One can transfer the segmentation of a first node to a target node, by using the split to introduce cuts in the target node at all positions where there are cuts in the first node.

2. mkCompatible(n1, n2, . . . ): This operator applies the split operator to its operands until their segmentations match. FIG. 7 illustrates the results of mkCompatible(s1, s2), where before the operation node s1 includes two segments, including a single bit segment 0 . . . 0 and a 31 bit segment 1 . . . 31, while node s2 includes two segments, including a two bit segment 32 . . . 33 and a 30 bit segment 34 . . . 63. In order for the segmentations to match, the 31 bit segment in node s1 must be split at location 1, and the two bit segment in node s2 must be split at location 1, resulting in matching segmentations as illustrated in the figure including three segments in both nodes s1 and s2, including two single bit segments and one 30 bit segment. After the make compatible operation mkCompatible(n1, n2, . . . ) is completed on a set of nodes, the segmentation of the nodes in the set is consistent with that of all other nodes in the set, because all the cuts in one of the nodes will then exist in all the other nodes.

3. bitblast(n): This operator applies the split operator to a node n until it is segmented into single bit slices.

The merge operator MergeDepGps(n1, n1, . . . ) takes a number of nodes whose segmentations match, having the same number of segments. The merge operator generates k new dependency groups by merging the dependency groups for all the first segments of its operands, merging the dependency groups for all the second segments of its operands and so on until k new dependency groups are formed. FIG. 8 illustrates the merge dependency group operation for nodes Sig0 and Sig1, where each of the nodes has a three bit segment (800, 801) and a 29 bit segment (802, 803). As a result of the operator, two new dependency classes (804, 805) are created which contain segments from both nodes Sig0 and Sig1.

FIGS. 9-13 illustrate a process for traversing an input data structure to produce a reduced netlist as described herein. The data flow analysis is performed by traversing the nodes in the data structure, which preferably has the form of a directed acyclic graph as mentioned above, in a depth first recursive manner where each node encountered is registered using the registerNode operator, and then processed (block 900).

If the node is a constant (block 901), the split operator is used to partition the node into its maximal segments of consecutive bits of the form 00 . . . 0 and 11 . . . 1 (block 902). Thus, the constant 000100 having the six locations 0-5, would be split into the segments (0,1), (2,2) and 3,5). Other techniques can be applied to constants which do not restrict the number of constants by dependency group to 2, including specific processing for each dependency group, or for selected types of dependency groups. The technique restricting the constants to 2, as described here is simple and fast, but may not lead to optimum segmentations.

If the node is a variable (block 903) then nothing is done (block 904).

If the node is the “not” in operator of the form node1 equal NOT node2 (block 905), then the bit blast operator is applied on node1 and node2, and then the merge dependency group operator is applied (block 906).

If the node is the “and” operator of the form node1 equal AND (node2, node3) (block 907), then the bit blast operator is applied on node1, node2 and node3, and then the merge dependency group operator is applied (block 908).

If the node is an arithmetic operator of the form node1 equal ARITHOP (node2, node3) (block 909), then the bit blast operator is applied on node1, node2 and node3, and then the merge dependency group operator is applied (block 910).

Proceeding to FIG. 10, if the node is a comparator operator of the form node1 equal compOp(node2 and node3), then the operation depends upon the type of operator (block 911). If the operator one of the “equal to” or “not equal to” operators (block 912), then the make compatible operator is applied over node1 and node2, and then the merge dependency group operator is applied (block 913). If the operator is one of the “less than”, “less than or equal to”, greater than or equal to” and “greater than” operators (block 914), then the bit blast operator is applied on node1 and node2, and then the merge dependency group operator is applied (block 915).

If the operator is a multiplexer operator of the form node1 equal MUX (selector, node2, node3) (block 916), then the make compatible operator is applied over node1, node2 and node3, and then the merge dependency group operator is applied (block 917).

If the operator is an extraction operator of the form node1 ^(k) equal EXTRACT (x, node2 ^(m)) (block 918), then the split operator is used to introduce cuts at bit position x, and bit position x+k, if x+k is less than the width m of node2, where k is the width of node1. Then, all the segment cuts in the region between bit position x, and bit position x+k, and node2 are transferred to node1. Then the merge dependency group operator is applied for node1 and node2 (block 919).

Proceeding to FIG. 11, if the operator is a concatenation operator of the form node1 equal concat(node2 ^(i), node3 ^(j) . . . ) (block 920), then node1 is segmented to match the operand borders (i.e. location i, location i+j, etc.), and all of the internal segment cuts in the operands are transferred to the corresponding points in node1. Then the merge dependency group operator is applied for node1 and node2 (block 921).

For example, consider the verification problem from FIG. 4. Assume we traverse the netlist by first visiting s0. This creates the partition information s0 : (0 . . . 8) in a singleton dependency group. After visiting nodes n3, n4, n5, i1, n2, i2 and n1 we have the new segmentation s0 : (0 . . . 2), (3 . . . 5), (6 . . . 8). The dependency group of s0 : (0 . . . 2), now contain the other elements n1 : (0 . . . 2), n2 : (0 . . . 2), n3 : (0 . . . 2), n4 : (0 . . . 2), n5 : (0 . . . 2), s0 : (3 . . . 5) and s0 : (6 . . . 8).

Next, it is determined whether all the nodes in the input data structure have been processed (block 922). If not, then the procedure returns to block 901 for a new node (block 923). If they have all been processed, then all current-state and next-state variable pairs, (node1, node1′) are traversed (block 924). First, the make compatible operator is applied for each pair, and the merge dependency group operator is applied for each pair (block 925). Finally, the split operator is used to ensure that the segmentation of each current state node is consistent with the segmentation of its initial state vector, which vector is used to set the value of a current state node when the simulation is started and which is segmented as a constraint like a constant as described with reference to block 901 (block 926).

After performing the data flow analysis, segment information for each node will result, with assurance that (1) the segmentation of current and next-state variables is consistent, (2) the segmentation of current-state variables and initial-state variables is consistent, and (3) the segment sources of size greater than one of the netlist DAG will only be propagated through multiplexer networks or be compared using the operators {equal to, not equal to}.

Proceeding to FIG. 12, at about this stage in the process, the algorithm visits each dependency group, and computes a new reduced size for the segments in the group by applying a resizing formula which guarantees that all properties of the node are preserved. The nodes are resized to the sum of the resized segments of the node (block 927). A resizing formula useful in step 927 can be explained as follows. The selectively bitblasted netlist now has two components: (1) A word-level component that reads packages from the inputs and word-level registers, moves them around using multiplexers, and performs package comparisons, and (2) A bit-level component that reads bit-level signals from the inputs, controls the multiplexers (possibly based on the outputs from comparison operators), and computes bit-level outputs. As the word-level variables are only compared for equality and inequality and moved around, they can be abstracted to provide reduced widths.

In a 1995 paper, Hojati and Brayton introduce a reduction for designs they refer to as Data Comparison Controllers (DCCs) (R. Hojati and R. Brayton. Automatic datapath abstraction in hardware systems, Proc. of the Computer Aided Verification Conf., 1995). These designs are partitioned into a boolean part and a datapath part that manipulate infinite packets modeled as integers by moving them around and comparing them, like the selectively bitblasted designs of the process described here. It is shown in Hojati and Brayton's paper that for every DCC, there always exists a finite smallest package size that preserves the status of the properties of the design. In fact, if the system has N infinite integer variables and M integer constant nodes, the integers can safely be modeled using length S_(min)=[log₂(N+M)] bit vectors.

This result cannot be applied directly here for two different reasons: (1) the selectively bitblasted packages do not have infinite initial size; and (2) there is more than one package size. However, as long as an initial packet size for a particular node is greater than some determinate minimum packet size, then the properties of the node will hold as long as a resized node is at least as large as the minimum of the initial packet size and the minimum packet size. A reduced safe size is determined for each dependency group, having an initial width greater than one. If the dependency group contains a number n constants, and a number m input and variable slices, then the reduced safe size is defined as: min(w_(i), log₂(n+m)). Also note that due to the partitioning of constants in the example procedure described above, every dependency group can have at most one “all zeroes” constant and one “all ones” constant, as described above. So, M (the number of constants of a particular length) is always less than or equal to two in this example. Of course, other techniques for handling constants can be used, in which there are more than 2 possible constants as mentioned above.

After selective bitblasting, the resulting netlist has no facility for converting a size N word-level segment into some other size segment. Segments of a different width can hence not be compared, or registered in the same word-level register slices. The converted designs are therefore generalized DCCs, with one bit-level component, and a finite number of separate word-level components that only communicate with each other using bit-level signals. By iterating the argument in Hojati and Brayton, it can be seen that each of these word-level components can be abstracted individually. Therefore, reduced safe size can be computed as follows:

For each segment of size S in a node in a particular dependency group, there exists a number N_(S) of state variable and input segments of size S in the dependency group. All properties of the selectively bitblasted netlist are preserved if the size S is adjusted to have a new size that is the min(S, log₂(N_(S)+2)). This results in a simple safe width. Also, other formulas or processes can be applied to find the minimum safe size, including more rigorous evaluation of the circuit represented by each dependency group to find a minimum safe size that may be smaller than found using the technique above.

When all word-level state variables and constants have been sized, the abstracted netlist is computed by rewriting the word-level components of the selectively bitblasted design to use variables and constants of the new correct size, and adjusting the width of the internal operators. So, returning to FIG. 12, the procedure progresses to produce a modified word-level netlist (block 950) by converting each node in the original netlist into a list of new nodes, including one node per segment.

The modified netlist is produced by traversing the nodes, determining the type of node, and then performing an appropriate operation as follows. If the node is a variable or constant node having a number n segments (block 928), then a list of the number n nodes is produced having the same node type, and sized according to the sizes assigned to the dependency groups of the segments (block 929).

If the node is one of a “not” and “and”, arithmetic operator, and a comparator operator of the type “less than”, “less than or equal to”, “greater than”, and “greater than or equal to” (block 930), then the previous processing will have produced single bit segmentation (bitblasted). So the resulting list of signals is returned corresponding to the bit-level implementation of the operator in terms of its inputs (block 931).

If the node is a comparator operator of the form node1 equal CompOp (node2, node3) (block 932), and the operator is one of the “equal to” or “not equal to” types, then node1 is implemented as a Boolean network of equalities over the respective segments (block 933).

If the node is a multiplexer operator of the form node1 equal MUX (selector, node2, node3) (block 934), then a list of multiplexers is produced of the form mux (selector, x,y), where each multiplexer takes a corresponding segmentation x, y of node2 and node3 (block 935). For example, assume that a 32-bit wide multiplexer node of the form mux³²(n1 ¹, n2 ³², n3 ³²) has been segmented into an 8-bit wide segment and a 16-bit wide segment (0 . . . 7), (8 . . . 31), and that the result of reimplementing n1 ¹ was [m1 ¹], and that the result of reimplementing n2 ³² and n3 ³² was [m2 ²⁴, m3 ⁸] and [m4 ²⁴, m5 ⁸], respectively. Then we return a 24 bit wide multiplexer and an 8-bit wide multiplexer as follows: [mux²⁴(m1 ¹, m2 ²⁴, m4 ²⁴), mux⁸(m1 ¹, m3 ⁸, m5 ⁸)].

Proceeding to FIG. 13, if the node is an extraction operator of the form node1 equal extract(x, node2) (block 936), then a new list of nodes is generated for the segmentation of node2 (block 937). FIG. 14 illustrates an example of an extraction operation of the form Sig2 ³=extract(x, Sig1), in which Sig1 is an 8-bit node that is a member of a dependency group 1400 with node Sig0. The extraction operator is a three bit wide operation producing a three bit wide node Sig2 1401, by extracting three bits starting at that location x in Sig1. Nodes Sig1 and Sig0 are split into a first set of three bit segments starting at that location x, which become members of dependency group 1402, with the output node Sig2, into single bit segments over bit location 0 which become members of dependency group 1403, and into a second set of three bit segments starting at bit location 4 which become members of the dependency group 1404.

If the node is a concatenation operator of the form node1 equal concat(node2, node3, . . . ) (block 938), then a concatenation of the list of new nodes (i.e., nodes resulting from processing of (node2, node3, . . . ) is generated for the operands (block 939).

Next, it is determined whether all the nodes in the data structure have been processed (block 940). If not, then the procedure returns to block 928 for a new node (block 941).

If they have all been processed, then in order to produce the final segmented data structure, a new next-state variable or output is provided at the top of the directed acyclic graph, at each of the new reduced nodes feeding the top of the graph (block 942). As a result of this processing, a selectively bitblasted netlist is produced (block 943). The selectively bitblasted netlist includes nodes operating on signals having a bit width of one, that is bit-level signals which get processed using standard Boolean logic. In addition, the selectively bitblasted netlist includes word-level nodes operating on signals having a bit width greater than one. The word-level signals are moved through the netlist in a multiplexer network, which generates bit-level signals using comparison operators. Also, an original input or state variable in the design may have been split into several parts, some of which are a bit-level and some of which are word-level.

In implementations of the technologies described above for particular netlists, constants are not shared among logic cones, because shared constants will force segmentation propagation from one cone to another unnecessarily. Thus, fresh variable nodes are introduced for each reference to a constant. At the end of the analysis, these introduced variable nodes are transformed back into constant nodes.

In addition, a circuit representation received from an HDL front end can be preprocessed to provide an improved starting point for the analysis. Specifically, the input netlists are swept to detect subgraphs where words are split up into bit-level signals, routed in a uniform way and recombined into word-level signals. These subgraphs are automatically re-implemented at the word-level.

In addition, symbolic memories represented as abstract read and write nodes can be processed as well. In this case, a write to memory, the segmentation of a value data transfers to all slots in the memory, and the value data becomes a member of the dependency class of all the slots in the memory. For a read, the segmentation from the memory will transfer to the output of the read node, and the dependency class of the output of the read node will include all the slots. In a write to an array with data having a particular segmentation, the segmentation is introduced to every memory location accessible by the write. In reads, the segmentation of the slots in the memory is applied to the read node.

A word-level model checking approach aimed at unbounded property checking for industrial netlists is described. The approach is based on a two-step method, where a quick analysis rewrites the netlist into a design where the word-level node segments that manipulate packages are completely separated from the rest of the logic. Then all packages are resized using statically computed safe lower bounds that guarantee preservation of the properties being checked. The resulting system can be analyzed using any standard bit-level model checking technique, or further processed using transformational verification simplifications.

While the present invention is disclosed by reference to the preferred embodiments and examples detailed above, it is to be understood that these examples are intended in an illustrative rather than in a limiting sense. It is contemplated that modifications and combinations will readily occur to those skilled in the art, which modifications and combinations will be within the spirit of the invention and the scope of the following claims. 

What is claimed is:
 1. A method for processing a computer implemented representation of a circuit design, comprising: representing the circuit design in memory accessible by a computer as a data structure defining a netlist as a plurality of nodes, and identifying a first set of nodes that includes word-level datapath nodes for corresponding words; using the computer, segmenting word-level datapath nodes in the first set of nodes in the data structure into segmented nodes having segment widths corresponding to uniformly treated segments of the corresponding words; using the computer, finding reduced safe sizes for the segmented nodes; and using the computer, generating an updated data structure representing the same circuit design, using the reduced safe sizes of the segmented nodes, wherein the reduced safe sizes of at least some of the segmented nodes are more than one bit.
 2. The method of claim 1, including converting a second set of word-level nodes in the plurality of nodes into bit-level nodes; and wherein said generating uses the bit-level nodes.
 3. The method of claim 2, wherein the first set of nodes includes word-level nodes representing comparison operators for (equal to) and (not equal to), word-level nodes representing multiplexer operators, word-level nodes representing concatenation operators, word-level nodes representing extraction operators, word-level nodes representing inputs, word-level nodes representing state variables and word-level nodes representing binary constants; and the second set of nodes includes word-level nodes representing arithmetic operators, word-level nodes representing comparison operators for (less than), (less than or equal to), (greater than), and (greater than or equal to), word-level nodes representing logical AND operators, and word-level nodes representing logical NOT operators.
 4. The method of claim 2, wherein said representing includes registering each node in the data structure and constructing a dependency group including the node containing a segment (0 . . . k−1) where the node has a width k; said segmenting includes performing an operation that splits nodes in the dependency group including a particular node in the first set until the segmentations of the nodes in the dependency group including the particular node match; and said converting includes performing an operation that splits nodes in the dependency group including a particular node in the second set, into single bit segments.
 5. The method of claim 4, wherein said segmenting includes performing a split operation for a node in a target bit position, including finding a dependency group including a segment of the node containing a target bit position, and if the target bit position is between the endpoints of the segment, dividing the dependency group into a first new dependency group containing the first bit positions of the segment including the target bit position, and a second new dependency group containing the remaining bit positions of the segment.
 6. The method of claim 4, wherein said updated data structure includes current state and next state variables, and said generating includes processing said current state and next state variables to ensure consistent segmentation, and that the current state and next state variables are members of the same dependency group.
 7. The method of claim 1, wherein said data structure represents the netlist as a directed acyclic graph, where top-level nodes include said word-level nodes representing circuit outputs and next-state variables, where bottom-level nodes include said word-level nodes representing inputs, state variables and binary constant vectors, and where internal nodes include said word-level nodes representing operators.
 8. The method of claim 1, including during said segmenting, maintaining partition lists identifying segments of corresponding nodes, and dependency groups, including segments of nodes in the graph that depend on segments of other nodes in the group or which have segments of other nodes in the group that depend on them.
 9. The method of claim 8, including maintaining said partition lists in a data structure organized for probabilistic search.
 10. The method of claim 8, including maintaining said partition lists in a skip list data structure.
 11. The method of claim 8, wherein the step of finding reduced safe sizes includes processing the segments of nodes in the dependency groups to find reduced safe sizes for the segments, and then summing the segments for each node.
 12. The method of claim 8, wherein the step of finding reduced safe sizes includes processing the segments of nodes in a particular dependency group to find reduced safe sizes for the segments, and then summing the segments for each node, where the dependency group includes a segments of width S, and a number N_(S) of state variable and input segments of size S, then the reduced safe size of segments in the dependency group is min(S, log₂(N_(S)+M)), where M is the number of constant segments within the dependency group.
 13. The method of claim 1, including analyzing the updated data structure to determine whether the circuit design satisfies a safety property.
 14. The method of claim 1, wherein the updated data structure comprises a netlist that preserves a provability status of a pre-specified property.
 15. The method of claim 1, including manufacturing an integrated circuit using said circuit design.
 16. A data processing system adapted to process a computer implemented representation of a circuit design, comprising: a data processor and memory coupled to the data processor, the memory storing instructions executable by the data processor to represent the circuit design in the memory as a data structure defining a netlist as a plurality of nodes; to identify a first set of nodes that includes word-level datapath nodes for corresponding words; to segment the first set of nodes in the data structure into segmented nodes having segment widths corresponding to uniformly treated segments of the corresponding words; to find reduced safe sizes for the segmented nodes; and to generate an updated data structure representing the same circuit design, using the reduced safe sizes of the segmented nodes, wherein the reduced safe sizes of at least some of the segmented nodes are more than one bit..
 17. The data processing system of claim 16, said instructions including instructions executable by the data processor to convert a second set of word-level nodes in the plurality of nodes into bit-level nodes; and wherein said instructions executable to generate the updated netlist use the bit-level nodes.
 18. The data processing system of claim 17, wherein the first set of nodes includes word-level nodes representing comparison operators for (equal to) and (not equal to), word-level nodes representing multiplexer operators, word-level nodes representing concatenation operators, word-level nodes representing extraction operators, word-level nodes representing inputs, word-level nodes representing state variables and word-level nodes representing binary constants; and the second set of nodes includes word-level nodes representing arithmetic operators, word-level nodes representing comparison operators for (less than), (less than or equal to), (greater than), and (greater than or equal to), word-level nodes representing logical AND operators, and word-level nodes representing logical NOT operators.
 19. The data processing system of claim 17, including instructions executable to register each node in the data structure and construct a dependency group including the node containing a segment (0 . . . k−1) where the node has a width k; said instructions executable to segment the first set of nodes to perform an operation that splits nodes in the dependency group including a particular node in the first set until the segmentations of the nodes in the dependency group including the particular node match; and said instructions executable to convert the second set of nodes to perform an operation that splits nodes in the dependency group, including a particular node in the second set, into single bit segments.
 20. The data processing system of claim 19, wherein said instructions executable to segment include instructions for performing a split operation for a node in a target bit position, including finding a dependency group including a segment of the node containing a target bit position, and instructions executable if the target bit position is between the endpoints of the segment, for dividing the dependency group into a first new dependency group containing the first bit positions of the segment including the target bit position, and a second new dependency group containing the remaining bit positions of the segment.
 21. The data processing system of claim 19, wherein said updated data structure includes current state and next state variables, and including instructions for processing said current state and next state variables to ensure consistent segmentation, and that the current state and next state variables are members of the same dependency group.
 22. The data processing system of claim 16, wherein said data structure represents the netlist as a directed acyclic graph, where top-level nodes include said word-level nodes representing circuit outputs and next-state variables, where bottom-level nodes include said word-level nodes representing inputs, state variables and binary constant vectors, and where internal nodes include said word-level nodes representing operators.
 23. The data processing system of claim 16, including instructions maintaining partition lists identifying segments of corresponding nodes, and dependency groups including segments of nodes in the graph that depend on segments of other nodes in the group or which have segments of other nodes in the group that depend on them for maintaining dependency groups, including segments of nodes in the graph that depend on segments of other nodes in the group or which have segments of other nodes in the group that depend on them.
 24. The data processing system of claim 23, wherein instructions for maintaining partition lists maintain said partition lists in a data structure organized for probabilistic search.
 25. The data processing system of claim 23, wherein instructions for maintaining partition lists maintain said partition lists in a skip list data structure.
 26. The data processing system of claim 23, wherein instructions to find reduced safe sizes include instructions for processing the segments of nodes in the dependency groups to find reduced safe sizes for the segments, and then summing the segments for each node.
 27. The data processing system of claim 23, wherein instructions to find reduced safe sizes include instructions for processing the segments of nodes in the dependency groups to find reduced safe sizes for the segments, and then summing the segments for each node, where the dependency group includes a segment of width S, and a number N_(S) of state variable and input segments of size S, then the reduced safe size of segments in the dependency group is min(S, log₂(N_(S)+M)), where M is the number of constant segments within the dependency group.
 28. An article of manufacture providing software adapted to process a computer implemented representation of a circuit design, comprising: a memory readable by a data processor, the memory storing instructions executable by the data processor to represent the circuit design in the memory as a data structure defining a netlist as a plurality of nodes; to identify a first set of nodes that includes word-level datapath nodes in the data structure; to segment the first set of nodes in the data structure into segmented nodes having segment widths corresponding to uniformly treated segments of the corresponding words; to find reduced safe sizes for the segmented nodes; and to generate an updated data structure representing the same circuit design, using the reduced safe sizes of the segmented nodes, wherein the reduced safe sizes of at least some of the segmented nodes are more than one bit. 